home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 19 / CU Amiga Magazine's Super CD-ROM 19 (1998)(EMAP Images)(GB)[!][issue 1998-02].iso / CUCD / Programming / LEDA / source / src / plane / _circle.c next >
Encoding:
C/C++ Source or Header  |  1994-11-16  |  4.2 KB  |  170 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  3.1c
  4. +
  5. +
  6. +  _circle.c
  7. +
  8. +
  9. +  Copyright (c) 1994  by  Max-Planck-Institut fuer Informatik
  10. +  Im Stadtwald, 6600 Saarbruecken, FRG     
  11. +  All rights reserved.
  12. + 
  13. *******************************************************************************/
  14.  
  15.  
  16.  
  17. #include <LEDA/circle.h>
  18. #include <math.h>
  19.  
  20. static const double eps = 1e-10;
  21.  
  22. //------------------------------------------------------------------------------
  23. // circles
  24. //------------------------------------------------------------------------------
  25.  
  26.  
  27. circle::circle()                        { PTR = new circle_rep; }
  28. circle::circle(const point& c, double r)       { PTR = new circle_rep(c,r); }
  29. circle::circle(double x, double y, double r)  
  30.                                         { PTR = new circle_rep(point(x,y),r); }
  31.   
  32.  
  33. int circle::operator==(const circle& c)  const
  34. { double dr =  fabs(ptr()->radius - c.ptr()->radius);
  35.   return (ptr()->center == c.ptr()->center && dr < eps);
  36.  }
  37.  
  38.  
  39. double circle::distance(const point& p) const
  40. { double d = p.distance(ptr()->center);
  41.   return (d - ptr()->radius);
  42.  }
  43.  
  44. double circle::distance(const line& l) const
  45. { double d = l.distance(ptr()->center);
  46.   return (d - ptr()->radius);
  47.  }
  48.  
  49. double circle::distance(const circle& c) const
  50. { double d = ptr()->center.distance(c.ptr()->center);
  51.   return (d - ptr()->radius - c.ptr()->radius);
  52.  }
  53.  
  54. bool circle::inside(const point& p) const 
  55. { return distance(p)<=0; }
  56.  
  57.  
  58. circle circle::translate(double alpha, double d) const
  59. { point p = ptr()->center.translate(alpha,d);
  60.   return circle(p,ptr()->radius);
  61.  }
  62.  
  63. circle circle::translate(const vector& v) const
  64. { point p = ptr()->center.translate(v);
  65.   return circle(p,ptr()->radius);
  66.  }
  67.  
  68. circle  circle::rotate(const point& o, double alpha) const
  69. { return circle(ptr()->center.rotate(o,alpha),ptr()->radius); 
  70.  }
  71.  
  72. circle  circle::rotate(double alpha)          const
  73. { return rotate(point(0,0),alpha);
  74.  }
  75.  
  76. list<point> circle::intersection(const line& l) const
  77. { list<point> result;
  78.   segment s = l.perpendicular(ptr()->center);
  79.   double  d = s.length();
  80.   double  r = ptr()->radius;
  81.   point   F = s.end();
  82.  
  83.   if (d==r) result.append(F);
  84.   
  85.   if (d < r)
  86.   { double alpha = l.angle();
  87.     double x = sqrt(r*r - d*d);
  88.     point  p = F.translate(alpha,x);
  89.     point  q = F.translate(alpha,-x);
  90.     result.append(q);
  91.     result.append(p);
  92.   }
  93.  
  94.   return result;
  95. }
  96.  
  97.  
  98. list<point> circle::intersection(const segment& s) const
  99. { list<point> result,L;
  100.  
  101.   L = intersection(line(s));
  102.  
  103.   point p;
  104.   double  d  = s.length();
  105.  
  106.   forall(p,L)
  107.   { double d1 = s.ptr()->start.distance(p);
  108.     double d2 = s.ptr()->end.distance(p);
  109.     if (d1 <= d && d2 <= d) result.append(p);
  110.    }
  111.  
  112.   return result;
  113. }
  114.  
  115. list<point> circle::intersection(const circle& c) const
  116. { list<point> result;
  117.   segment s(ptr()->center, c.ptr()->center);
  118.   double d  = s.length();
  119.   double r1 = ptr()->radius;
  120.   double r2 = c.ptr()->radius;
  121.  
  122.   if (d > (r1+r2) || (d+r2) < r1 || (d+r1) < r2) return result;
  123.  
  124.  
  125.   double x = (d*d + r1*r1 - r2*r2)/(2*d);
  126.   double alpha = acos(x/r1);
  127.   double beta  = s.angle() + alpha;
  128.   double gamma = s.angle() - alpha;
  129.  
  130.   result.append(ptr()->center.translate(beta,r1));
  131.   if (alpha!=0) result.append(ptr()->center.translate(gamma,r1));
  132.  
  133.   return result;
  134.  }
  135.  
  136.  
  137. segment circle::left_tangent(const point& p) const
  138. { if (inside(p)) error_handler(1,"left_tangent:: point inside circle");
  139.   segment s(p,ptr()->center);
  140.   double d = s.length();
  141.   double alpha = asin(ptr()->radius/d) + s.angle();
  142.   point touch = p.translate(alpha,sqrt(d*d - ptr()->radius*ptr()->radius));
  143.   return segment(p,touch);
  144. }
  145.  
  146. segment circle::right_tangent(const point& p) const
  147. { if (inside(p)) error_handler(1,"right_tangent:: point inside circle");
  148.   segment s(p,ptr()->center);
  149.   double d = s.length();
  150.   double alpha = s.angle() - asin(ptr()->radius/d);
  151.   point touch = p.translate(alpha,sqrt(d*d - ptr()->radius*ptr()->radius));
  152.   return segment(p,touch);
  153. }
  154.  
  155. ostream& operator<<(ostream& out, const circle& c) 
  156. { out << c.center() << " "<< c.radius(); 
  157.   return out;
  158.  } 
  159.  
  160. istream& operator>>(istream& in,  circle& c) 
  161. { point cent;
  162.   double rad;
  163.   if (in) in >> cent;
  164.   if (in) in >> rad;
  165.   c = circle(cent,rad);
  166.   return in;
  167. }
  168.  
  169.  
  170.